home *** CD-ROM | disk | FTP | other *** search
/ Creative Computers / Creative Computers CD-ROM, Volume 1 (Legendary Design Technologies, Inc.)(1994).iso / shareware / intuition / yak_1.57 / source / help.c < prev    next >
C/C++ Source or Header  |  1994-11-17  |  15KB  |  693 lines
  1. /*
  2.  * help.c
  3.  * 
  4.  * Opens help/settings window and handles events.
  5.  * For yak.
  6.  * 
  7.  * Martin W. Scott, 12-Sep-92.
  8.  */
  9. #include <exec/types.h>
  10. #include <dos/dosextens.h>
  11. #include <graphics/gfxmacros.h>
  12. #include <libraries/commodities.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <intuition/intuition.h>
  15. #include <libraries/gadtools.h>
  16. #include <proto/exec.h>
  17. #include <proto/dos.h>
  18. #include <proto/intuition.h>
  19. #include <proto/gadtools.h>
  20. #include <proto/graphics.h>
  21. #include <proto/commodities.h>
  22. #include <string.h>
  23.  
  24. #include "yak.h"
  25. #include "hotkey_types.h"
  26. #include "popup.h"
  27. #include "version.h"
  28.  
  29. #define CATCOMP_NUMBERS
  30. #include "yak_locale_strings.h"
  31.  
  32. static struct Window *curwin;
  33.  
  34. /* static protos */
  35. static void __regargs InitHelpGadget(UWORD num, LONG tagtype, LONG tagvalue);
  36. static void InitHelpGadgets(void);
  37. static void __regargs InitHotKeyGadget(UWORD num, LONG tagtype, LONG tagvalue);
  38. static void InitHotKeyGadgets(void);
  39. static void __regargs InitMiscGadget(UWORD num, LONG tagtype, LONG tagvalue);
  40. static void InitMiscGadgets(void);
  41. static void __regargs NewPattern(UWORD gdx, UWORD n, struct Gadget *gad);
  42. static BOOL ShowHelpWindow(void);
  43. static BOOL ShowHotKeyWindow(void);
  44. static BOOL ShowMiscWindow(void);
  45. static BOOL SwitchToHotkeyWindow(void);
  46. static BOOL SwitchToMiscWindow(void);
  47. static LONG HandleHelpIDCMP(void);
  48. static LONG HandleHotKeyIDCMP(void);
  49. static LONG HandleMiscIDCMP(void);
  50.  
  51.  
  52. /* menu numbers */
  53. #define LOAD 0
  54. #define SAVE 1
  55. #define HIDE 2
  56. #define QUIT 3
  57.  
  58. /* initialise individual gadget in help window */
  59. static void __regargs
  60. InitHelpGadget(UWORD num, LONG tagtype, LONG tagvalue)
  61. {
  62.     GT_SetGadgetAttrs(HelpGadgets[num], HelpWnd, NULL, tagtype, tagvalue, TAG_DONE);
  63. }
  64.  
  65. /* initialise all gadgets */
  66. static void
  67. InitHelpGadgets(void)
  68. {
  69.     UWORD    i;
  70.  
  71.     for (i = 0; i < NUM_TOGGLES; i++)
  72.         if (toggles[i].gadid != -1)
  73.             InitHelpGadget(toggles[i].gadid,
  74.                    GTCB_Checked,
  75.                    toggles[i].pos); 
  76.  
  77.     InitHelpGadget(GDX_ScrTONum, GTIN_Number, blanksecs);
  78.     InitHelpGadget(GDX_MouseTONum, GTIN_Number, mblanksecs);
  79.     InitHelpGadget(GDX_AutoPat, GTST_String, (LONG)patterns[YP_AUTOSCR_PAT].patstr);
  80.     InitHelpGadget(GDX_ClickPat, GTST_String, (LONG)patterns[YP_CLICKSCR_PAT].patstr);
  81.     InitHelpGadget(GDX_PopPat, GTST_String, (LONG)patterns[YP_POPWIN_PAT].patstr);
  82.     InitHelpGadget(GDX_ClickWinPat, GTST_String, (LONG)patterns[YP_CLICKWIN_PAT].patstr);
  83.     InitHelpGadget(GDX_ClickWinPat, GTCY_Active, qualifier);
  84. }
  85.  
  86. /* show current window */
  87. BOOL
  88. ShowWindow(void)
  89. {
  90.     
  91.     if (curwin)        /* already opened */
  92.     {
  93.         ScreenToFront(curwin->WScreen);
  94.         WindowToFront(curwin);
  95.         ActivateWindow(curwin);
  96.         return TRUE;
  97.     }
  98.  
  99.     if (SetupScreen())    
  100.         return FALSE;
  101.     
  102.     return ShowHelpWindow();
  103. }
  104.  
  105.  
  106.  
  107. /* show our help window */
  108. static BOOL
  109. ShowHelpWindow(void)
  110. {
  111.     InitGUI ();
  112.  
  113.     if (!OpenHelpWindow())    /* like the name says... */
  114.     {
  115.         InitHelpGadgets();
  116.         wndsigflag = 1 << HelpWnd->UserPort->mp_SigBit;
  117.         curwin = HelpWnd;
  118.         return TRUE;
  119.     }
  120.     CloseDownScreen();
  121.     return FALSE;
  122. }
  123.  
  124. /* show our hotkey window */
  125. static BOOL
  126. ShowHotKeyWindow(void)
  127. {
  128.     if (!OpenHotKeyWindow())    /* like the name says... */
  129.     {
  130.         InitHotKeyGadgets();
  131.         wndsigflag = 1 << HotKeyWnd->UserPort->mp_SigBit;
  132.         curwin = HotKeyWnd;
  133.         return TRUE;
  134.     }
  135.     CloseDownScreen();
  136.     return FALSE;
  137. }
  138.  
  139. /* show our misc window */
  140. static BOOL
  141. ShowMiscWindow(void)
  142. {
  143.     if (!OpenMiscWindow())    /* like the name says... */
  144.     {
  145.         InitMiscGadgets();
  146.         wndsigflag = 1 << MiscWnd->UserPort->mp_SigBit;
  147.         curwin = MiscWnd;
  148.         return TRUE;
  149.     }
  150.     CloseDownScreen();
  151.     return FALSE;
  152. }
  153.  
  154.  
  155. /* update windows position for next openings */
  156. void
  157. UpdateWindowsPosition (void)
  158. {
  159.     HelpLeft = curwin->LeftEdge;
  160.     WindowTop = curwin->TopEdge;
  161. }
  162.  
  163.  
  164. /* hide our window */
  165. void
  166. HideWindow(void)
  167. {
  168.     if (curwin)
  169.     {
  170.         UpdateWindowsPosition();
  171.         if (curwin == HelpWnd)
  172.             CloseHelpWindow();
  173.         else
  174.             if (curwin == MiscWnd)
  175.                 CloseMiscWindow();
  176.             else
  177.                 CloseHotKeyWindow();
  178.         
  179.         CloseDownScreen();
  180.         wndsigflag = NULL;
  181.         curwin = HelpWnd = HotKeyWnd = MiscWnd = NULL;
  182.     }
  183. }
  184.  
  185. /* switch from help window to hotkey window */
  186. static BOOL
  187. SwitchToHotkeyWindow(void)
  188. {
  189.         HotKeyLeft = HelpWnd->LeftEdge;
  190.         WindowTop = HelpWnd->TopEdge;
  191.         CloseHelpWindow();
  192.         return ShowHotKeyWindow();
  193. }
  194.  
  195. /* switch from help window to misc window */
  196. static BOOL
  197. SwitchToMiscWindow(void)
  198. {
  199.         MiscLeft = HelpWnd->LeftEdge;
  200.         WindowTop = HelpWnd->TopEdge;
  201.         CloseHelpWindow();
  202.         return ShowMiscWindow();
  203. }
  204.  
  205.  
  206.  
  207. /* handle pattern string-gadget */
  208. static void __regargs
  209. NewPattern(UWORD gdx, UWORD n, struct Gadget *gad)
  210. {
  211.     char *newpatstr;
  212.  
  213.     newpatstr = GetString(gad);
  214.     if (!InitPattern(newpatstr, n))
  215.     {
  216.         DisplayBeep(Scr);
  217.         InitHelpGadget(gdx, GTST_String, (LONG)patterns[n].patstr);
  218.     }
  219. }
  220.  
  221. /* handle window events */
  222. LONG
  223. HandleIDCMP(void)
  224. {
  225.     if (curwin == HelpWnd)
  226.         return HandleHelpIDCMP();
  227.     else    
  228.         if (curwin == MiscWnd)
  229.             return HandleMiscIDCMP();
  230.         else
  231.         return HandleHotKeyIDCMP();
  232. }
  233.  
  234. /* handle help window events */
  235. static LONG
  236. HandleHelpIDCMP(void)
  237. {
  238.     struct IntuiMessage *msg;
  239.     struct Gadget   *gadget;
  240.     ULONG           class;
  241.     UWORD        code;
  242.     LONG        num;
  243.  
  244.     while (msg = GT_GetIMsg(HelpWnd->UserPort))
  245.     {
  246.         class = msg->Class;
  247.         code = msg->Code;
  248.         gadget = (struct Gadget *)msg->IAddress;
  249.         GT_ReplyIMsg(msg);
  250.  
  251.         switch (class)
  252.         {
  253.         case CLOSEWINDOW:
  254.             HideWindow();
  255.             return HELP_OKAY;
  256.  
  257.         case GADGETUP:
  258.         case GADGETDOWN:
  259.             switch (gadget->GadgetID)
  260.             {
  261.             case GD_EditHotkeys: 
  262.                 if (!SwitchToHotkeyWindow())
  263.                     PostError(getString(Couldnt_open_other_window_ERR));
  264.                 return HELP_OKAY;
  265.  
  266.             case GD_Miscellaneous: 
  267.                 if (!SwitchToMiscWindow())
  268.                     PostError(getString(Couldnt_open_other_window_ERR));
  269.                 return HELP_OKAY;
  270.  
  271.             case GD_AutoPat:
  272.                 NewPattern(GDX_AutoPat, YP_AUTOSCR_PAT, gadget);
  273.                 break;
  274.  
  275.             case GD_ClickPat:
  276.                 NewPattern(GDX_ClickPat, YP_CLICKSCR_PAT, gadget);
  277.                 break;
  278.  
  279.             case GD_PopPat:
  280.                 NewPattern(GDX_PopPat, YP_POPWIN_PAT, gadget);
  281.                 break;
  282.  
  283.             case GD_ClickWinPat:
  284.                 NewPattern(GDX_ClickWinPat, YP_CLICKWIN_PAT, gadget);
  285.                 break;
  286.  
  287.             case GD_Hide:
  288.                 HideWindow();
  289.                 return HELP_OKAY;
  290.  
  291.             case GD_Quit:
  292.                 HideWindow();
  293.                 return HELP_QUIT;
  294.  
  295.             case GD_AutoCheck:    /* toggle */
  296.                 autopoint ^= TRUE;
  297.                 break;
  298.  
  299.             case GD_AutoPopCheck:    /* toggle */
  300.                 autopop ^= TRUE;
  301.                 break;
  302.  
  303.             case GD_KeyActCheck:    /* toggle */
  304.                 keyactivate ^= TRUE;
  305.                 break;
  306.  
  307.             case GD_CTFCheck:    /* toggle */
  308.                 clicktofront ^= TRUE;
  309.                 break;
  310.  
  311.             case GD_CTBCheck:    /* toggle */
  312.                 clicktoback ^= TRUE;
  313.                 break;
  314.  
  315.             case GD_ScrCycleCheck:    /* toggle */
  316.                 screencycle ^= TRUE;
  317.                 break;
  318.  
  319.             case GD_WildStarCheck:    /* toggle */
  320.                 wildstar ^= TRUE;
  321.                 if (wildstar) WILDSTARON; else WILDSTAROFF;
  322.                 break;
  323.  
  324.             case GD_NoClickCheck:    /* toggle */
  325.                 noclick ^= TRUE;
  326.                 SetClickDrive(noclick);
  327.                 break;
  328.  
  329.             case GD_ScrActCheck:    /* toggle */
  330.                 scractivate ^= TRUE;
  331.                 break;
  332.  
  333.             case GD_RMBActCheck:    /* toggle */
  334.                 rmbactivate ^= TRUE;
  335.                 break;
  336.  
  337.             case GD_MMBActCheck:    /* toggle */
  338.                 mmbactivate ^= TRUE;
  339.                 break;
  340.  
  341.             case GD_ScrTONum:
  342.                 num = GetNumber(gadget);
  343.                 if (num >= 0) {
  344.                     blanksecs = num;
  345.                     blankcount = blanktimeout = blanksecs*10;
  346.                 } else {
  347.                     InitHelpGadget(GDX_ScrTONum, GTIN_Number, blanksecs);
  348.                     DisplayBeep(HelpWnd->WScreen);
  349.                 }
  350.                 break;
  351.  
  352.             case GD_MouseTONum:
  353.                 num = GetNumber(gadget);
  354.                 if (num >= 0) {
  355.                     mblanksecs = num;
  356.                     mblankcount = mblanktimeout = mblanksecs*10;
  357.                 } else {
  358.                     InitHelpGadget(GDX_MouseTONum, GTIN_Number, mblanksecs);
  359.                     DisplayBeep(HelpWnd->WScreen);
  360.                 }
  361.                 break;
  362.  
  363.             } /* switch (gadget->GadgetID) */
  364.             break;
  365.  
  366.         case REFRESHWINDOW:
  367.             GT_BeginRefresh(HelpWnd);
  368.             HelpRender();
  369.             GT_EndRefresh(HelpWnd, TRUE);
  370.             break;
  371.  
  372.         case IDCMP_MENUPICK:
  373.             while (code != MENUNULL) 
  374.             {
  375.                 struct MenuItem *item = ItemAddress(HelpMenus, code);
  376.  
  377.                 switch (ITEMNUM(code))
  378.                 {
  379.                 case LOAD:
  380.                     LoadSettings();
  381.                     InitHelpGadgets();
  382.                     break;
  383.                 case SAVE:
  384.                     SaveSettings();
  385.                     break;
  386.                 case HIDE:
  387.                     HideWindow();
  388.                     return HELP_OKAY;
  389.                 case QUIT:
  390.                     HideWindow();
  391.                     return HELP_QUIT;
  392.                 }
  393.                 code = item->NextSelect;
  394.  
  395.             } /* while more menuchoices */
  396.             break;
  397.  
  398.         } /* switch (class) */
  399.  
  400.     } /* wh